home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / seyon / SeGeneric.c < prev    next >
C/C++ Source or Header  |  1995-06-21  |  6KB  |  288 lines
  1.  
  2. /*
  3.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  4.  * Saggaf. All rights reserved.
  5.  *
  6.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  7.  * statement of rights and permissions for this program.
  8.  */
  9.  
  10. #include "config.h"
  11.  
  12. #include <stdio.h>
  13. #ifndef NOSTDHDRS
  14. #include <stdlib.h>
  15. #endif
  16. #ifndef SCO
  17. #include <unistd.h>
  18. #endif
  19. #include <signal.h>
  20. #include <setjmp.h>
  21. #include <errno.h>
  22. #include <sys/types.h>
  23. #include <sys/time.h>
  24. #include <ctype.h>
  25. #include <math.h>
  26.  
  27. #include "SeDecl.h"
  28.  
  29. void
  30. ReadCommentedFile(fp, line)
  31.      FILE           *fp;
  32.      char           *line[];
  33. {
  34.   char            buffer[REG_BUF + 1],
  35.                  *bufPtr,
  36.                  *ptr;
  37.   int             i;
  38.  
  39.   for (i = 0; i < MAX_ENT && fgets(buffer, REG_BUF, fp) != NULL;) {
  40.  
  41.     /*Strip newline character from end of string*/
  42.     buffer[strlen(buffer) - 1] = '\0';
  43.  
  44.     /*Remove leading and trailing spaces*/
  45.     bufPtr = SSpc(buffer);
  46.  
  47.     /*Ignore this line if it is empty or starts with a comment*/
  48.     if (bufPtr[0] == '\0' || bufPtr[0] == '#')
  49.       continue;
  50.  
  51.     /*Ignore trailing comments*/
  52.     if ((ptr = (char *) strrchr(bufPtr, '#')) != NULL)
  53.       *ptr = '\0';
  54.  
  55.     line[i++] = XtNewString(bufPtr);
  56.   }
  57.  
  58.   line[i] = NULL;
  59. }
  60.  
  61. void
  62. FreeList(listArr)
  63.      XtPointer       listArr[];
  64. {
  65.   int             i;
  66.  
  67.   for (i = 0; listArr[i]; i++)
  68.     XtFree(listArr[i]);
  69.  
  70.   listArr[0] = NULL;
  71. }
  72.  
  73. int
  74. ConvertStringToIntArray(str, intArr)
  75.      char *str;
  76.      int  intArr[];
  77. {
  78.   char num[TIN_BUF], *numPtr;
  79.   int i;
  80.   
  81.   intArr[0] = 0;
  82.  
  83.   if (!str) return 0;
  84.  
  85.   for (i = 0;;) {
  86.     while (isspace(*str)) str++;
  87.     if (!*str) return 0;
  88.  
  89.     for (numPtr = num; *str && !isspace(*str); *numPtr++ = *str++);
  90.     *numPtr = '\0';
  91.     intArr[i] = atoi(num);
  92.     intArr[++i] = 0;
  93.   }
  94. }
  95.  
  96. /* ------------------------------------------------------------
  97.  * Routines to read from the tty.
  98.  */
  99.  
  100. /*
  101.  * TtyReadStr: reads a bunch of characters from the modem.
  102.  */
  103.  
  104. int
  105. TtyReadStr(fd, buf)
  106.      int             fd;
  107.      char           *buf;
  108. {
  109.   int      count;
  110.  
  111.   /* The do-loop is used to restart the system call if it is interrupted by 
  112.      a signal. This is simpler than missing with SA_INTERRUPT */
  113.   do
  114.     /* BUFSIZ is defined in stdio.h */
  115.     count = read(fd, buf, BUFSIZ);
  116.   while (count < 0 && errno ==  EINTR);
  117.  
  118.   if (count < 0) {
  119.     SePError("character read"); 
  120.     return -1;
  121.   }
  122.  
  123.   return count;
  124. }
  125.  
  126. jmp_buf         timedReadEnv;
  127.  
  128. void
  129. timedReadAlarmHandler(dummy)
  130.      int             dummy;
  131. {
  132.   longjmp(timedReadEnv, 1);
  133. }
  134.  
  135. int
  136. TtyTimedReadChar(fd, readChar, expireTime)
  137.      int             fd;
  138.      char           *readChar;
  139.      int             expireTime;
  140. {
  141.   /* BUFSIZ is defined in stdio.h */
  142.   static char     readBuf[BUFSIZ],
  143.                  *bufPtr;
  144.   static int      count = 0;
  145.   static void     (*oldSigHandler)();
  146.   static unsigned oldAlarmTimeLeft;
  147.  
  148.   if (count > 0) {
  149.     count--;
  150.     *readChar = *++bufPtr;
  151.     return 0;
  152.   }
  153.  
  154.   if (expireTime > 0) {
  155.     oldSigHandler = signal(SIGALRM, timedReadAlarmHandler);
  156.     oldAlarmTimeLeft = alarm((unsigned)expireTime);
  157.  
  158.     if (setjmp(timedReadEnv) != 0) {
  159.       alarm(max(oldAlarmTimeLeft - expireTime, 0));
  160.       signal(SIGALRM, oldSigHandler);
  161.       return -1;
  162.     }
  163.   }
  164.  
  165.   count = TtyReadStr(fd, (bufPtr = readBuf));
  166.  
  167.   if (expireTime > 0) {
  168.     alarm(max(oldAlarmTimeLeft - expireTime + alarm(0), 0));
  169.     signal(SIGALRM, oldSigHandler);
  170.   }
  171.  
  172.   if (count < 0) return count;
  173.  
  174.   count--;
  175.   *readChar = *bufPtr;
  176.  
  177.   return 0;
  178. }
  179.  
  180. /*
  181.  * TtyReadChar: reads one character from the tty.
  182.  */
  183.  
  184. char
  185. TtyReadChar(fd, readChar)
  186.      int             fd;
  187.      char           *readChar;
  188. {
  189.   return TtyTimedReadChar(fd, readChar, 0);
  190. }
  191.  
  192. /*---------------------------------------------------------------------------+
  193. | TtyReadLine - reads one line from the tty.
  194. +---------------------------------------------------------------------------*/
  195.  
  196. int
  197. TtyReadLine(fd, buf)
  198.      int             fd;
  199.      char           *buf;
  200. {
  201.   char            c;
  202.   int             i, readCharRet;
  203.  
  204.   while ((readCharRet = TtyReadChar(fd, &c)) >= 0 && (c == '\r' || c == '\n'));
  205.   if (readCharRet < 0) return readCharRet;
  206.  
  207.   i = 0;
  208.   do buf[i++] = c;
  209.   while ((readCharRet = TtyReadChar(fd, &c)) >=0 && (c != '\r' && c != '\n'));
  210.   
  211.   buf[i] = '\0';
  212.   return readCharRet;
  213. }
  214.  
  215. int
  216. TtyTimedWaitFor(fd, expectedString, waitTime)
  217.      int             fd;
  218.      char           *expectedString;
  219.      int             waitTime;
  220. {
  221.   time_t          expireTime;
  222.   char            c, *ptr = expectedString;
  223.  
  224.   expireTime = time((time_t*)0) + waitTime;
  225.  
  226.   while (expireTime != time((time_t*)0)) {
  227.     if ((TtyTimedReadChar(fd, &c, 1)) < 0)
  228.       continue;
  229.  
  230.     if ((char)c != *ptr) ptr = expectedString;
  231.     else if (*++ptr == '\0') return 0;
  232.   } /* while... */
  233.  
  234.   return -1;
  235. }
  236.  
  237. /* ------------------------------------------------------------
  238.  * Miscellaneous routines.
  239.  */
  240.  
  241. /*
  242.  * usleep: for systems that do not have it.
  243.  */
  244.  
  245. #if !HAVE_USLEEP
  246. void
  247. usleep(usec)
  248.      unsigned long usec;
  249. {
  250. #if HAVE_SELECT
  251.  
  252.   /* Orest Zborowski originally wrote this */
  253.  
  254.   struct timeval  timeout;
  255.  
  256.   timeout.tv_sec = usec / 1000000;
  257.   timeout.tv_usec = usec - 1000000 * timeout.tv_sec;
  258.   select(1, NULL, NULL, NULL, &timeout);
  259. #else
  260.  
  261. /* This busy-waiting, normally a bad idea on a multi-tasking system, is used
  262.    because sleep(1) is way too much of a delay. */
  263.  
  264.   int             i;
  265.  
  266.   for (i = 0; i < usec; i++);
  267. #endif /* HAVE_SELECT */
  268. }
  269. #endif /* HAVE_USLEEP */
  270.  
  271. /* 
  272.  * dup2: for systems that do not have it.
  273.  */
  274.  
  275. #if !HAVE_DUP2
  276. int
  277. dup2(oldfd, newfd)
  278.      int             oldfd,
  279.                      newfd;
  280. {
  281.   if (fcntl(oldfd, F_GETFL, 0) == -1)    /* Valid file descriptor? */
  282.     return (-1);           /* No, return an error. */
  283.   close(newfd);               /* Ensure newfd is closed */
  284.   return (fcntl(oldfd, F_DUPFD, newfd));    /* Dup oldfd into newfd */
  285. }
  286.  
  287. #endif /* HAVE_DUP2  Thanks to Bill Allie CIS: 76703,2061 */
  288.